package adapter

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/mars/internal/admin/core/application/client"
	"github.com/mars/internal/admin/core/application/service"
	"github.com/mars/internal/admin/core/domain"
	"github.com/mars/internal/pkg/gins"
	"github.com/mars/pkg/errors"
)

type ProductController struct {
	srv       service.Service
	validator *domain.ProductValidator
}

func NewProductController(fc domain.Factory) *ProductController {
	return &ProductController{
		srv:       service.NewService(fc),
		validator: domain.NewProductValidator(),
	}
}

// GetProductList 获取商品列表
// @Summary 获取商品列表
// @Description 分页查询商品信息，支持按类型、状态筛选和关键字搜索
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param page query int false "页码" default(1)
// @Param size query int false "每页数量" default(20)
// @Param type query string false "商品类型" Enums(vip,ticket,physical)
// @Param status query string false "商品状态" Enums(active,inactive)
// @Param keyword query string false "关键字搜索"
// @Param sort query string false "排序字段" default(createTime)
// @Param order query string false "排序方向" Enums(asc,desc) default(desc)
// @Success 200 {object} map[string]interface{} "{"data": [商品列表], "total": 总数}"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/list [get]
func (pc *ProductController) GetProductList(cxt *gin.Context) (interface{}, int64, error) {
	// 使用domain层验证器验证查询参数
	params, err := pc.validator.ValidateQueryParams(cxt)
	if err != nil {
		return nil, 0, err
	}

	products, total, err := pc.srv.ProductSrv().GetProductList(cxt, params)
	if err != nil {
		return nil, 0, err
	}

	// 转换为view层结构体
	productViews := client.ToProductViewList(products)
	return productViews, total, nil
}

// GetProduct 根据ID获取商品详情
// @Summary 获取商品详情
// @Description 根据商品ID查询商品详细信息
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param id path string true "商品ID"
// @Success 200 {object} domain.Product "商品详细信息"
// @Failure 400 {object} map[string]interface{} "商品ID参数缺失"
// @Failure 404 {object} map[string]interface{} "商品不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/detail/{id} [get]
func (pc *ProductController) GetProduct(cxt *gin.Context) (interface{}, error) {
	// 使用domain层验证器验证商品ID
	productID, err := pc.validator.ValidateProductID(cxt, "id")
	if err != nil {
		return nil, err
	}

	product, err := pc.srv.ProductSrv().GetProduct(cxt, productID)
	if err != nil {
		return nil, err
	}

	productView := client.ToProductView(product)
	return productView, nil
}

// CreateProduct 创建新商品
// @Summary 创建新商品
// @Description 创建新商品，支持VIP会员、入场券、实物商品三种类型
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param product body domain.Product true "商品信息"
// @Success 200 {object} map[string]interface{} "{"message": "Product created successfully"}"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/create [post]
func (pc *ProductController) CreateProduct(cxt *gin.Context) (*gins.Response, error) {
	var product domain.Product
	if err := cxt.ShouldBindJSON(&product); err != nil {
		return nil, errors.New(http.StatusBadRequest, "invalid JSON format: "+err.Error())
	}

	// 使用domain层验证器验证商品数据
	if err := pc.validator.ValidateProduct(&product); err != nil {
		return nil, err
	}

	err := pc.srv.ProductSrv().CreateProduct(cxt, &product)
	if err != nil {
		return nil, err
	}

	return gins.NewSuccessResponse("商品创建成功"), nil
}

// GenerateUploadUrls 生成商品图片上传链接
// @Summary 生成商品图片上传链接
// @Description 生成商品图片上传链接
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param id path string true "商品ID"
// @Param filenames body []string true "文件名列表"
// @Success 200 {array} string "上传链接列表"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/upload/{id} [post]
func (pc *ProductController) GenerateUploadUrls(cxt *gin.Context) (interface{}, error) {
	var filenames []string
	if err := cxt.ShouldBindJSON(&filenames); err != nil {
		return nil, errors.New(http.StatusBadRequest, "invalid JSON format: "+err.Error())
	}

	urls, err := pc.srv.ProductSrv().GenerateUploadUrls(cxt, filenames)
	if err != nil {
		return nil, err
	}

	return urls, nil
}

// UploadProductImage 上传商品图片文件
// @Summary 上传商品图片文件
// @Description 支持多文件上传，文件类型限制为图片格式（jpg/jpeg/png/gif）,单文件最大10MB，最多10个文件
// @Tags 商品管理
// @Accept multipart/form-data
// @Produce json
// @Param id path string true "商品ID"
// @Param files formData file true "上传的图片文件（支持多文件）"
// @Success 200 {array} domain.UploadResult "上传结果列表"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 404 {object} map[string]interface{} "商品不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/upload-images [post]
func (pc *ProductController) UploadProductImage(cxt *gin.Context) (interface{}, error) {
	// 解析表单文件
	form, err := cxt.MultipartForm()
	if err != nil {
		return nil, errors.New(http.StatusBadRequest, "解析文件上传表单失败: "+err.Error())
	}
	// 调用服务层上传文件
	results, err := pc.srv.ProductSrv().UploadProductImages(cxt, form)
	if err != nil {
		return nil, err
	}

	return results, nil
}

// UpdateProduct 更新商品信息
// @Summary 更新商品信息
// @Description 根据商品ID更新商品信息，支持部分字段更新
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param id path string true "商品ID"
// @Param product body domain.Product true "商品信息"
// @Success 200 {object} map[string]interface{} "{"message": "Product updated successfully"}"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 404 {object} map[string]interface{} "商品不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/update/{id} [put]
func (pc *ProductController) UpdateProduct(cxt *gin.Context) (*gins.Response, error) {
	// 使用domain层验证器验证商品ID
	productID, err := pc.validator.ValidateProductID(cxt, "id")
	if err != nil {
		return nil, err
	}

	var product domain.Product
	if err := cxt.ShouldBindJSON(&product); err != nil {
		return nil, errors.New(http.StatusBadRequest, "invalid JSON format: "+err.Error())
	}

	// 使用domain层验证器验证商品数据
	err = pc.srv.ProductSrv().UpdateProduct(cxt, productID, &product)
	if err != nil {
		return nil, err
	}

	return gins.NewSuccessResponse("商品更新成功"), nil
}

// DeleteProduct 删除商品
// @Summary 删除商品
// @Description 软删除商品（设置状态为inactive）
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param id path string true "商品ID"
// @Success 200 {object} map[string]interface{} "{"message": "Product deleted successfully"}"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 404 {object} map[string]interface{} "商品不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/delete/{id} [delete]
func (pc *ProductController) DeleteProduct(cxt *gin.Context) (interface{}, error) {
	// 使用domain层验证器验证商品ID
	productID, err := pc.validator.ValidateProductID(cxt, "id")
	if err != nil {
		return nil, err
	}

	err = pc.srv.ProductSrv().DeleteProduct(cxt, productID)
	if err != nil {
		return nil, err
	}

	return gin.H{"message": "Product deleted successfully"}, nil
}

// GetProductsByType 根据类型获取商品列表
// @Summary 根据类型查询商品
// @Description 根据商品类型（vip/ticket/physical）查询商品列表
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param type path string true "商品类型" Enums(vip,ticket,physical)
// @Success 200 {array} domain.Product "商品列表"
// @Failure 400 {object} map[string]interface{} "类型参数错误或无效"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/type/{type} [get]
func (pc *ProductController) GetProductsByType(cxt *gin.Context) (interface{}, error) {
	// 使用domain层验证器验证商品类型
	productType, err := pc.validator.ValidateProductType(cxt, "type")
	if err != nil {
		return nil, err
	}

	products, err := pc.srv.ProductSrv().GetProductsByType(cxt, productType)
	if err != nil {
		return nil, err
	}

	// 转换为view层结构体
	productViews := client.ToProductViewList(products)
	return productViews, nil
}

// GetProductsByStatus 根据状态获取商品列表
// @Summary 根据状态查询商品
// @Description 根据商品状态（active/inactive）查询商品列表
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param status path string true "商品状态" Enums(active,inactive)
// @Success 200 {array} domain.Product "商品列表"
// @Failure 400 {object} map[string]interface{} "状态参数错误或无效"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/status/{status} [get]
func (pc *ProductController) GetProductsByStatus(cxt *gin.Context) (interface{}, error) {
	// 使用domain层验证器验证商品状态
	productStatus, err := pc.validator.ValidateProductStatus(cxt, "status")
	if err != nil {
		return nil, err
	}

	products, err := pc.srv.ProductSrv().GetProductsByStatus(cxt, productStatus)
	if err != nil {
		return nil, err
	}

	// 转换为view层结构体
	productViews := client.ToProductViewList(products)
	return productViews, nil
}

// UpdateProductStatus 更新商品状态
// @Summary 更新商品状态
// @Description 更新商品上架/下架状态
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param id path string true "商品ID"
// @Param status body object true "{"status": "active|inactive"}"
// @Success 200 {object} map[string]interface{} "{"message": "Product status updated successfully"}"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 404 {object} map[string]interface{} "商品不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/status/{id} [put]
func (pc *ProductController) UpdateProductStatus(cxt *gin.Context) (*gins.Response, error) {
	// 使用domain层验证器验证商品ID
	productID, err := pc.validator.ValidateProductID(cxt, "id")
	if err != nil {
		return nil, err
	}

	var req struct {
		Status domain.ProductStatus `json:"status" binding:"required"`
	}
	if err := cxt.ShouldBindJSON(&req); err != nil {
		return nil, errors.New(http.StatusBadRequest, "invalid JSON format: "+err.Error())
	}

	// 使用domain层验证器验证状态值
	if err := pc.validator.ValidateUpdateStatusRequest(req.Status); err != nil {
		return nil, err
	}

	err = pc.srv.ProductSrv().UpdateProductStatus(cxt, productID, req.Status)
	if err != nil {
		return nil, err
	}

	return gins.NewSuccessResponse("Product status updated successfully"), nil
}

// UpdateProductStock 更新商品库存
// @Summary 更新商品库存
// @Description 更新实物商品的库存数量
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param id path string true "商品ID"
// @Param stock body object true "{"stock": 100}"
// @Success 200 {object} map[string]interface{} "{"message": "Product stock updated successfully"}"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 404 {object} map[string]interface{} "商品不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/stock/{id} [put]
func (pc *ProductController) UpdateProductStock(cxt *gin.Context) (*gins.Response, error) {
	// 使用domain层验证器验证商品ID
	productID, err := pc.validator.ValidateProductID(cxt, "id")
	if err != nil {
		return nil, err
	}

	var req struct {
		Stock int `json:"stock" binding:"required,min=0"`
	}
	if err := cxt.ShouldBindJSON(&req); err != nil {
		return nil, errors.New(http.StatusBadRequest, "invalid JSON format: "+err.Error())
	}

	// 使用domain层验证器验证库存值
	if err := pc.validator.ValidateUpdateStockRequest(req.Stock); err != nil {
		return nil, err
	}

	err = pc.srv.ProductSrv().UpdateProductStock(cxt, productID, req.Stock)
	if err != nil {
		return nil, err
	}

	return gins.NewSuccessResponse("Product stock updated successfully"), nil
}

// GetProductStats 获取商品统计信息
// @Summary 获取商品统计信息
// @Description 获取商品数量的多维度统计信息
// @Tags 商品管理
// @Accept json
// @Produce json
// @Success 200 {object} domain.ProductStats "统计信息"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/stats [get]
func (pc *ProductController) GetProductStats(cxt *gin.Context) (interface{}, error) {
	stats, err := pc.srv.ProductSrv().GetProductStats(cxt)
	if err != nil {
		return nil, err
	}

	return stats, nil
}

// SearchProducts 搜索商品
// @Summary 搜索商品
// @Description 根据关键字搜索商品
// @Tags 商品管理
// @Accept json
// @Produce json
// @Param keyword query string true "搜索关键字"
// @Success 200 {array} domain.Product "商品列表"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/product/search [get]
func (pc *ProductController) SearchProducts(cxt *gin.Context) (interface{}, error) {
	// 使用domain层验证器验证搜索关键字
	keyword, err := pc.validator.ValidateSearchKeyword(cxt)
	if err != nil {
		return nil, err
	}

	products, err := pc.srv.ProductSrv().SearchProducts(cxt, keyword)
	if err != nil {
		return nil, err
	}

	// 转换为view层结构体
	productViews := client.ToProductViewList(products)
	return productViews, nil
}
